home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 March / EnigmA AMIGA RUN 05 (1996)(G.R. Edizioni)(IT)[!][issue 1996-03][Skylink CD IV].iso / earcd / util2 / dmouse.lha / DMouse / dlineart.c < prev    next >
C/C++ Source or Header  |  1995-11-07  |  31KB  |  1,695 lines
  1. #define VERSION "1.4gmd "
  2.  
  3. /***************************************************************
  4.  *
  5.  *  DLineArt.c
  6.  *
  7.  *  DMouse screen blanker for use with DMouse V1.20
  8.  *
  9.  *  read the docs file for installation procedures.
  10.  *
  11.  *  Is your computer BORED? If so, then you need...
  12.  *
  13.  *              DLineArt, by Steve -Raz- Berry with help
  14.  *              from Matt Dillon.
  15.  *
  16.  *
  17.  **************************************************************/
  18.  
  19. // Hacked by Gary Duncan (GMD)
  20. /* *INDENT-OFF* */
  21. #if 0
  22.  
  23.  Functions:-
  24.     
  25.     main 
  26.     LineArt 
  27.     InitScrStructures 
  28.     screenoff 
  29.     screenon 
  30.     do_text 
  31.     do_ellipse 
  32.     do_box 
  33.     checkbounce_start 
  34.     checkbounce_end 
  35.     get_rand_point 
  36.     get_rand_dir 
  37.     get_rand_scale 
  38.     do_spline 
  39.     openlibs 
  40.     closelibs 
  41.     my_ran 
  42.     hexit 
  43.     get_flags 
  44.     pause 
  45.     open_timer 
  46.     time_diff 
  47.     ChangeColour 
  48.     mouse_off 
  49.     mouse_on 
  50.     Midpoint 
  51.     DrawBezierArc 
  52.     usage 
  53.         fatal_err
  54.  
  55. #endif
  56.  
  57. /* *INDENT-ON* */
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67. #include <stdlib.h>
  68. #include <stdio.h>
  69. #include <exec/types.h>
  70. #include <ctype.h>
  71. #include <fcntl.h>
  72. #include <string.h>
  73.  
  74. #include <exec/memory.h>
  75. #include <intuition/preferences.h>
  76. #include <intuition/screens.h>
  77. #include <libraries/dos.h>
  78. #include <libraries/dosextens.h>
  79. #include <dos/dos.h>
  80. #include <exec/lists.h>
  81. #include <exec/nodes.h>
  82. #include <time.h>
  83. #include <clib/dos_protos.h>
  84. #include <clib/intuition_protos.h>
  85. #include <clib/graphics_protos.h>
  86. #include <proto/dos.h>
  87. #include <proto/exec.h>
  88. #include <devices/timer.h>
  89. #include <clib/timer_protos.h>
  90. #include <graphics/text.h>    /*GMD */
  91.  
  92. __far extern struct Custom custom;
  93.  
  94. typedef struct real_point
  95.   {
  96.     LONG x;
  97.     LONG y;
  98.   }
  99. LONG_POINT;
  100.  
  101. typedef enum
  102.   {
  103.     COL_RGB, COL_RANDOM
  104.   }
  105. MY_COL;
  106.  
  107.  
  108. #include "dmouse.h"
  109. #include "Proto/dlineart_protos.h"
  110.  
  111. /*
  112.  *  port name (Dmouse -> Dlineart IPC)
  113.  */
  114. #define DLINEART_PORT "Dlineart-DMHandler"
  115.  
  116. /*
  117.  *  port name (DlineArt Internal timer - GMD)
  118.  */
  119. #define DLINEART_TIMER "Dlineart-Timer"
  120.  
  121. /*
  122.  *  prog name
  123.  */
  124. #define DLINEART "dlineart"
  125.  
  126. #define MAXELLIPSE 75
  127. #define MINBOUND 20
  128. #define BOUNDX MAXX-MINBOUND
  129. #define BOUNDY MAXY-MINBOUND
  130.  
  131. /*
  132.  * defaults for starting Dlineart
  133.  */
  134.  
  135. #define DL_PAT_TIME    (30*1000)
  136. #define DL_CHG_SPD    (2*1000)
  137. #define Z_FACTOR    (5 * 1000)
  138. #define DL_STR        "BOING!"
  139.  
  140. /*
  141.  * flag bits
  142.  */
  143.  
  144. #define F_FLAG        0x20    /* must be last */
  145. #define F_TEXTSTR    0x10
  146. #define F_SPLINES    0x8
  147. #define F_LINES        0x4
  148. #define F_BOXES        0x2
  149. #define F_ELLIPSES    0x1
  150.  
  151. #define TEXT_LEN    20
  152.  
  153. typedef struct options
  154.   {
  155.     LONG flags;
  156.     LONG flags_orig;
  157.     LONG pat_count;
  158.     LONG pat_chg_time;
  159.     LONG input;
  160.     LONG z_delay;
  161.     LONG col_chg_spd;
  162.     MY_COL col_chg_mode;
  163.     LONG maxlines;
  164.     LONG trails;
  165.     char text[TEXT_LEN];
  166.     LONG debug;
  167.     char *debug2;
  168.   }
  169. DL_OPTIONS;
  170.  
  171.  
  172. static char A_vers[] = "$VER: dlineart\t" VERSION __AMIGADATE__;
  173.  
  174. static char Version[] = "dlineart\t" VERSION __DATE__;
  175.  
  176. UWORD Mouse[1 + 9 + 1];        /* must be 0 */
  177.  
  178.  
  179. static DL_OPTIONS g_dl_options;
  180.  
  181. static UWORD colour_tbl[2] =
  182. {
  183.   0x000,            /* background color - black */
  184.   0x500
  185. };
  186.  
  187. static DL_OPTIONS *dl = &g_dl_options;
  188. static DL_OPTIONS *g_dlb = NULL;
  189.  
  190. static int MAXX;
  191. static int MAXY;
  192. static char *g_TStr;
  193. static int g_TLen;
  194.  
  195.  
  196. INTUITIONBASE *IntuitionBase;
  197. LIBRARY *TimerBase = NULL;
  198. static GFXBASE *GfxBase;
  199. static VIEWPORT *vp;
  200. static SCREEN *Scr;
  201. static WINDOW *Win;
  202.  
  203. RASTPORT *rp;
  204. static TEXTATTR Ta =
  205. {(UBYTE *) "topaz.font", 11, 0, 0};    /*GMD */
  206.  
  207. static NEWSCREEN Ns =
  208. {0, 0, 0, 0, 1, 255, 255, HIRES | LACE, CUSTOMSCREEN | SCREENQUIET, &Ta};
  209.  
  210. static NEWWINDOW Nw =
  211. {0, 0, 0, 0, 2, 1, NULL, BORDERLESS | NOCAREREFRESH | BACKDROP,
  212.  NULL, NULL, NULL, NULL, NULL, 0, 0, 8000, 8000, CUSTOMSCREEN};
  213.  
  214. static LONG g_offset = 0;
  215. static LONG g_scale1 = 2;
  216. static LONG g_scale2 = 2;
  217. static LONG g_Count = 0;
  218.  
  219. static int f_mask = 1;
  220.  
  221. #define DL_STR  "BOING!"
  222.  
  223.  
  224. typedef struct XY
  225.   {
  226.     LONG x;
  227.     LONG y;
  228.   }
  229. XY;
  230.  
  231. typedef struct DIRECTION
  232.   {
  233.     XY start;
  234.     XY end;
  235.   }
  236. DIRECTION;
  237.  
  238. /* 
  239.  * Maximum # of lines,boxes,ellipses to draw (watch your stack!) 
  240.  */
  241.  
  242. #define ML 500
  243. static XY point_start[ML];
  244. static XY point_end[ML];
  245.  
  246. static DIRECTION direction;
  247.  
  248. static TIMEREQUEST *t_req;
  249. static MSGPORT *timerport;
  250. static ULONG e_freq;
  251. static ECLOCKVAL ec1;
  252. static ECLOCKVAL ec2;
  253.  
  254. static ECLOCKVAL col_ec1;
  255. static ECLOCKVAL col_ec2;
  256.  
  257. static LONG eloop_count;
  258.  
  259. static MSGPORT *dmport;
  260. static MSGPORT *ipport;
  261. static char xbuf[256];
  262. static TASK *e_task_ptr;
  263. static TASK *n_task_ptr;
  264. static MSGPORT *dla_port_ptr;
  265.  
  266. static BOOL is_back = FALSE;
  267.  
  268. extern __far ULONG RangeSeed;
  269.  
  270. /*
  271.  *********************************************************************
  272.  */
  273.  
  274. main (int argc, char **argv)
  275.  
  276. {
  277.   int var;
  278.   IOREQUEST AddReq;        /* for dmouse ipc       */
  279.   IOREQUEST RemReq;
  280.   BOOL notdone = TRUE;
  281.   LONG mask = 0;
  282.   int mouse_flag = 0;
  283.  
  284.   /* 
  285.    * see if already running      
  286.    */
  287.   Forbid ();
  288.   dla_port_ptr = FindPort (DLINEART_PORT);
  289.   Permit ();
  290.  
  291.   /*
  292.    *  background DLineArt task exists if Dlineart-Dmouse port exists
  293.    */
  294.   if (dla_port_ptr != NULL)
  295.     {
  296.       PROCESS *pr;
  297.       COMMANDLINEINTERFACE *cli;
  298.  
  299.       pr = (PROCESS *) FindTask (NULL);
  300.  
  301.       /*
  302.        * exit if this is another 'Run Dlineart..' invocation 
  303.        */
  304.       cli = (COMMANDLINEINTERFACE *) BADDR (pr->pr_CLI);
  305.  
  306.       if (cli->cli_Background == DOSTRUE)
  307.     {
  308.       fatal_err ("\nDlineart already running\n");
  309.     }
  310.  
  311.       /*
  312.        * get ptr to running DlineArt's parameter area from its TCB
  313.        */
  314.       e_task_ptr = dla_port_ptr->mp_SigTask;
  315.       g_dlb = e_task_ptr->tc_UserData;
  316.  
  317.       /*
  318.        * copy its option struct 
  319.        */
  320.       *dl = *g_dlb;
  321.  
  322.       dl->pat_count = 0;
  323.       dl->flags = 0;
  324.       dl->flags_orig = 0;
  325.     }
  326.   else
  327.     /*
  328.      * .. it hasn't started; so find one's TCB 
  329.      *    and init struct
  330.      */
  331.     {
  332.       is_back = TRUE;
  333.  
  334.       n_task_ptr = FindTask (NULL);
  335.       dl = &g_dl_options;
  336.       n_task_ptr->tc_UserData = dl;
  337.  
  338.       /*
  339.        * init struct with some defaults
  340.        */
  341.       dl->flags = 0;
  342.       dl->flags_orig = 0;
  343.       dl->pat_count = 0;
  344.       dl->pat_chg_time = DL_PAT_TIME;
  345.       dl->input = 3;
  346.       dl->z_delay = 2 * Z_FACTOR;
  347.       dl->col_chg_spd = DL_CHG_SPD;
  348.       dl->col_chg_mode = COL_RGB;
  349.       dl->maxlines = 20;
  350.       dl->trails = 1;
  351.  
  352.       strcpy (dl->text, DL_STR);
  353.     }
  354.  
  355.   /*
  356.    *** scan input params
  357.    */
  358.  
  359.   while (--argc >= 1)
  360.     {
  361.       LONG temp;
  362.  
  363.       char *ptr = argv[argc];
  364.  
  365.       if (*ptr++ == '-')
  366.     {
  367.       switch (*ptr++)
  368.         {
  369.         case 'b':
  370.           ++dl->pat_count;
  371.           dl->flags_orig |= F_BOXES;
  372.           dl->flags = F_BOXES;
  373.           break;
  374. #if 0
  375.         case 'c':
  376.           if (*ptr && (*ptr == 'R'))
  377.         {
  378.           dl->col_chg_mode = COL_RANDOM;
  379.         }
  380.           else
  381.         {
  382.           dl->col_chg_mode = COL_RGB;
  383.         }
  384.           break;
  385. #endif
  386.         case 'e':
  387.           ++dl->pat_count;
  388.           dl->flags_orig |= F_ELLIPSES;
  389.           dl->flags = F_ELLIPSES;
  390.           break;
  391.  
  392.         case 'h':        /* Help ; GMD */
  393.           usage ();
  394.           hexit ();
  395.  
  396.         case 'i':        /* new ; GMD */
  397.           temp = atoi (ptr);
  398.           if (temp < 1)
  399.         temp = 1;
  400.           else if (temp > 9)
  401.         temp = 9;
  402.  
  403.           dl->input = temp;
  404.           break;
  405.  
  406.         case 'p':        /* pattern change */
  407.           temp = atoi (ptr);
  408.           if (temp < 1)
  409.         temp = 10;
  410.  
  411.           dl->pat_chg_time = temp * 1000;
  412.           break;
  413.  
  414.         case 'l':
  415.           dl->maxlines = atoi (ptr);
  416.           if (dl->maxlines > ML)
  417.         {
  418.           dl->maxlines = ML;
  419.         }
  420.           else if (dl->maxlines < 1)
  421.         {
  422.           dl->maxlines = 1;
  423.         }
  424.           break;
  425.  
  426.         case 'q':        /* new (quit); GMD */
  427.           if (e_task_ptr == NULL)
  428.         {
  429.           printf ("%s", DLINEART " not running\n");
  430.         }
  431.           else
  432.         {
  433.           printf ("%s",
  434.               DLINEART " active; sending quit signal ( ^C)\n");
  435.           Signal (e_task_ptr, SIGBREAKF_CTRL_C);    /* stop it */
  436.         }
  437.           hexit ();
  438.  
  439.         case 'T':
  440.           ++dl->pat_count;
  441.           dl->flags_orig |= F_TEXTSTR;
  442.           dl->flags = F_TEXTSTR;
  443.           strncpy (dl->text, ptr, TEXT_LEN - 1);
  444.           g_TStr = dl->text;
  445.           g_TLen = strlen (g_TStr);
  446.           break;
  447.  
  448.         case 'z':        /* (GMD)  delay factor (0-9, 5 msecs per unit) */
  449.           {
  450.         int temp = atoi (ptr);
  451.  
  452.         if (temp > 9)
  453.           temp = 9;    /* silent max */
  454.  
  455.         dl->z_delay = temp * Z_FACTOR;    /*  chosen by testing */
  456.           }
  457.           break;
  458.  
  459.         case 'S':        /* change-colour Speed */
  460.           {
  461.         int temp = atoi (ptr);
  462.  
  463.         if (temp < 1)
  464.           temp = 1;
  465.  
  466.         dl->col_chg_spd = temp * 1000;
  467.           }
  468.           break;
  469.  
  470.         case 's':
  471.           ++dl->pat_count;
  472.           dl->flags_orig |= F_SPLINES;
  473.           dl->flags = F_SPLINES;
  474.           break;
  475.  
  476.         case 't':
  477.           dl->trails = 0;
  478.           break;
  479.  
  480.         case 'v':        /* print params  */
  481.  
  482.  
  483.           if (dla_port_ptr == NULL)
  484.         {
  485.           printf ("Dlineart not running\n");
  486.           hexit ();
  487.         }
  488.  
  489.           v_option ();
  490.           exit (0);
  491.  
  492.         default:
  493.           printf ("Error: (%s) invalid option\n", --ptr);
  494.           hexit ();
  495.         }
  496.     }
  497.       else
  498.     {
  499.       sprintf (xbuf, "Error: (%s) not an option\n", --ptr);
  500.       fatal_err (xbuf);
  501.     }
  502.  
  503.     }
  504.   /*
  505.    *** END of scan input params
  506.    */
  507.  
  508.   /*
  509.    * if not background, then a param update to background dlineart
  510.    */
  511.   if (is_back == FALSE)
  512.     {
  513.       if (dl->pat_count)
  514.     {
  515.       g_dlb->pat_count = dl->pat_count;
  516.  
  517.       if (g_dlb->flags != dl->flags)
  518.         {
  519.           g_dlb->flags = dl->flags;
  520.         }
  521.       if (g_dlb->flags_orig != dl->flags_orig)
  522.         {
  523.           g_dlb->flags_orig = dl->flags_orig;
  524.         }
  525.     }
  526.       if (g_dlb->pat_chg_time != dl->pat_chg_time)
  527.     {
  528.       g_dlb->pat_chg_time = dl->pat_chg_time;
  529.     }
  530.       if (g_dlb->input != dl->input)
  531.     {
  532.       g_dlb->input = dl->input;
  533.     }
  534.       if (g_dlb->z_delay != dl->z_delay)
  535.     {
  536.       g_dlb->z_delay = dl->z_delay;
  537.     }
  538.       if (g_dlb->col_chg_spd != dl->col_chg_spd)
  539.     {
  540.       g_dlb->col_chg_spd = dl->col_chg_spd;
  541.     }
  542.       if (g_dlb->col_chg_mode != dl->col_chg_mode)
  543.     {
  544.       g_dlb->col_chg_mode = dl->col_chg_mode;
  545.     }
  546.       if (g_dlb->maxlines != dl->maxlines)
  547.     {
  548.       g_dlb->maxlines = dl->maxlines;
  549.     }
  550.       if (g_dlb->trails != dl->trails)
  551.     {
  552.       g_dlb->trails = dl->trails;
  553.     }
  554.       if (strcmp (g_dlb->text, dl->text) != 0)
  555.     {
  556.       strcpy (g_dlb->text, dl->text);
  557.     }
  558.  
  559.       hexit ();
  560.     }
  561.  
  562.   /*
  563.    *** create i/p port for DMouse-Handler access 
  564.    */
  565.  
  566.   ipport = CreatePort (DLINEART_PORT, 0);    /*  ipc port    */
  567.   if (ipport == NULL)
  568.     {
  569.       fatal_err ("Can't create port for DMouse access\n");
  570.     }
  571.  
  572.   /*
  573.    *** come here only for 1st background invocation 'Run Dlineart ..'
  574.    *   (GMD) now open Timer for use in slowing display (-z option)
  575.    */
  576.  
  577.   /*
  578.    * set up some default flags
  579.    */
  580.  
  581.   if (dl->flags == 0)
  582.     {
  583.       dl->pat_count = 3;
  584.       dl->flags = F_BOXES;
  585.       dl->flags_orig = F_SPLINES | F_BOXES | F_ELLIPSES;
  586.     }
  587.  
  588.  
  589.   open_timer ();
  590.  
  591.   /*
  592.    *** open Libraries 
  593.    */
  594.  
  595.   openlibs ();
  596.  
  597.   InitScrStructures ();
  598.  
  599.   for (var = 0; var < VBeamPos (); ++var)
  600.     get_rand_point ();
  601.  
  602.   /*
  603.    * Init starting points
  604.    */
  605.  
  606.   point_start[0].x = get_rand_point ();
  607.   /* Initial start x,y (one endpoint) */
  608.   point_start[0].y = get_rand_point ();
  609.  
  610.   point_end[0].x = get_rand_point ();
  611.   point_end[0].y = get_rand_point ();
  612.  
  613.   direction.start.x = get_rand_dir ();
  614.   direction.start.y = get_rand_dir ();
  615.  
  616.   direction.end.x = get_rand_dir ();
  617.   direction.end.y = get_rand_dir ();
  618.  
  619.   /*
  620.    * let Dmouse-handler know I'm here ... 
  621.    */
  622.  
  623.   AddReq.io_Message.mn_ReplyPort = ipport;
  624.   AddReq.io_Command = DMCMD_ADDHANDLER;
  625.   AddReq.io_Unit = (UNIT *) dl->debug2;
  626.   AddReq.io_Flags = SBF_BOTH;    /* screen blanker, and mouse blanker */
  627.  
  628.   Forbid ();
  629.   if (dmport = FindPort (DMOUSE_IPC))
  630.     PutMsg (dmport, &AddReq.io_Message);
  631.   Permit ();
  632.  
  633.   if (dmport == NULL)
  634.     {
  635.       fatal_err ("DMouse not running or < V1.20\n");
  636.     }
  637.  
  638.   mask = SIGBREAKF_CTRL_C | (1 << ipport->mp_SigBit);
  639.  
  640.   /*
  641.    * infinite loop ; wait for Dmouse signals, or CTRL-C 
  642.    */
  643.  
  644.   while (notdone == TRUE)
  645.     {
  646.       ULONG sig_result;
  647.  
  648.       mouse_flag = 0;
  649.  
  650.       /*
  651.        * if DlineArt active (Scr) , test signals else Wait
  652.        */
  653.       if (Scr)
  654.     sig_result = SetSignal (0L, mask);
  655.       else
  656.     sig_result = Wait (mask);
  657.  
  658.       /*
  659.        *  if CTRL_C set loop exit flag 
  660.        */
  661.  
  662.       if (sig_result & SIGBREAKF_CTRL_C)
  663.     notdone = FALSE;
  664.  
  665.       /*
  666.        * if a signal from dmouse-handler, process its message
  667.        */
  668.  
  669.       if (sig_result & (1 << ipport->mp_SigBit))
  670.     {
  671.       IOREQUEST *ior;
  672.       while (ior = (IOREQUEST *) GetMsg (ipport))
  673.         {
  674.           if (ior->io_Message.mn_Node.ln_Type == NT_REPLYMSG)
  675.         {
  676.           notdone = FALSE;
  677.           continue;
  678.         }
  679.           switch (ior->io_Command)
  680.         {
  681.         case DMCMD_SCREENON:
  682.  
  683.           e_freq = ReadEClock (&ec1);
  684.           col_ec1 = ec1;
  685.  
  686.           screenon ();
  687.           break;
  688.  
  689.         case DMCMD_SCREENOFF:
  690.           screenoff ();
  691.           break;
  692.  
  693.         case DMCMD_MOUSEOFF:
  694.           mouse_off ();
  695.           break;
  696.  
  697.         case DMCMD_MOUSEON:
  698.           mouse_on ();
  699.           break;
  700.  
  701.         case DMCMD_PLEASEREMOVE:
  702.           notdone = FALSE;
  703.           break;
  704.         }
  705.           ReplyMsg (&ior->io_Message);
  706.         }
  707.     }
  708.       if (Win)
  709.     {
  710.  
  711.       /*
  712.        * Now go and draw something ...
  713.        */
  714.       if (dl->z_delay)
  715.         {
  716.           pause (dl->z_delay);    /* slow down maybe (-z option) */
  717.         }
  718.       /*
  719.        * fancy screen drawing done here...
  720.        */
  721.  
  722.       LineArt ();
  723.     }
  724.     }
  725.  
  726.   /*
  727.    * dlineart killed (^C); clean up and exit
  728.    */
  729.  
  730.  
  731.   screenon ();
  732.   mouse_on ();
  733.  
  734.   RemReq.io_Message.mn_ReplyPort = ipport;
  735.   RemReq.io_Command = DMCMD_REMHANDLER;
  736.   RemReq.io_Unit = (UNIT *) dl->debug2;
  737.  
  738.  
  739.   PutMsg (dmport, &RemReq.io_Message);
  740.   {
  741.     IOREQUEST *ior = NULL;
  742.     while (ior != &AddReq)
  743.       {
  744.     WaitPort (ipport);
  745.     ior = (IOREQUEST *) GetMsg (ipport);
  746.     if (ior->io_Message.mn_Node.ln_Type == NT_MESSAGE)
  747.       ReplyMsg (&ior->io_Message);
  748.  
  749.       }
  750.   }
  751.  
  752.   hexit ();
  753. }
  754.  
  755. /*
  756.  *********************************************************************
  757.  */
  758.  
  759. /*
  760.  * called from loop in main ()
  761.  */
  762.  
  763. void
  764. LineArt ()
  765. {
  766.   int newoffs, tempx, tempy;
  767.  
  768.   SetAPen (rp, 1L);
  769.  
  770.   switch (dl->flags)
  771.     {
  772.     case F_LINES:
  773.       Move (rp, point_start[g_offset].x, point_start[g_offset].y);
  774.       Draw (rp, point_end[g_offset].x, point_end[g_offset].y);
  775.       break;
  776.  
  777.     case F_ELLIPSES:
  778.       do_ellipse (g_offset);
  779.       break;
  780.  
  781.     case F_BOXES:
  782.       do_box (g_offset);
  783.       break;
  784.  
  785.     case F_SPLINES:
  786.       do_spline (g_offset);
  787.       break;
  788.  
  789.     case F_TEXTSTR:
  790.       do_text (g_offset);
  791.       break;
  792.     }
  793.  
  794.   /*
  795.    * start x,y
  796.    */
  797.   if (checkbounce_start (g_offset))
  798.     {
  799.       tempx = direction.start.x;
  800.       tempy = direction.start.y;
  801.  
  802.       if (point_start[g_offset].x <= MINBOUND)
  803.     {
  804.       direction.start.x = 1;
  805.     }
  806.       else
  807.     {
  808.       if (point_start[g_offset].x >= BOUNDX)
  809.         direction.start.x = -1;
  810.       else
  811.         direction.start.x = get_rand_dir ();
  812.     }
  813.  
  814.       if (point_start[g_offset].y <= MINBOUND)
  815.     {
  816.       direction.start.y = 1;
  817.     }
  818.       else
  819.     {
  820.       if (point_start[g_offset].y >= BOUNDY)
  821.         direction.start.y = -1;
  822.       else
  823.         direction.start.y = get_rand_dir ();
  824.     }
  825.  
  826.       g_scale1 = get_rand_scale ();
  827.     }
  828.  
  829.   /*
  830.    * end x,y
  831.    */
  832.   if (checkbounce2 (g_offset))
  833.     {
  834.       tempx = direction.end.x;
  835.       tempy = direction.end.y;
  836.  
  837.  
  838.       if (point_end[g_offset].x <= MINBOUND)
  839.     {
  840.       direction.end.x = 1;
  841.     }
  842.       else
  843.     {
  844.       if (point_end[g_offset].x >= BOUNDX)
  845.         direction.end.x = -1;
  846.       else
  847.         direction.end.x = get_rand_dir ();
  848.     }
  849.  
  850.       if (point_end[g_offset].y <= MINBOUND)
  851.     {
  852.       direction.end.y = 1;
  853.     }
  854.       else
  855.     {
  856.       if (point_end[g_offset].y >= BOUNDY)
  857.         direction.end.y = -1;
  858.       else
  859.         direction.end.y = get_rand_dir ();
  860.     }
  861.  
  862.       g_scale2 = get_rand_scale ();
  863.     }
  864.  
  865.   /*
  866.    * now see if time to change colour 
  867.    */
  868.   ++g_Count;
  869.  
  870.   e_freq = ReadEClock (&col_ec2);
  871.   if (time_diff (e_freq, &col_ec1, &col_ec2) > dl->col_chg_spd)
  872.     {
  873.       col_ec1 = col_ec2;
  874.  
  875.       ChangeColour (dl->col_chg_mode);
  876.     }
  877.  
  878.   /*
  879.    * now see if time to change pattern
  880.    */
  881.  
  882.   e_freq = ReadEClock (&ec2);
  883.   if (time_diff (e_freq, &ec1, &ec2) > dl->pat_chg_time)
  884.     {
  885.       ec1 = ec2;
  886.       /*
  887.        * Change colour , also
  888.        */
  889.  
  890.       ChangeColour (dl->col_chg_mode);
  891.  
  892.       g_Count = dl->maxlines;
  893.       if ((dl->trails == 0) || (dl->pat_count > 1))
  894.     {
  895.       g_Count = 0;
  896.       g_offset = 0;
  897.       Move (rp, 0, 0);
  898.       ClearScreen (rp);
  899.  
  900.       /*
  901.        * if multiple patterns, select next
  902.        */
  903.       if (dl->pat_count > 1)
  904.         {
  905.           int j = 32;
  906.           while (--j)
  907.         {
  908.           f_mask = f_mask << 1;
  909.           if (f_mask & F_FLAG)
  910.             f_mask = 1;
  911.  
  912.           if (dl->flags_orig & f_mask)
  913.             {
  914.               dl->flags = f_mask;
  915.               break;
  916.             }
  917.         }
  918.         }
  919.     }
  920.     }
  921.  
  922.   ++g_offset;
  923.  
  924.   if (g_offset > dl->maxlines)
  925.     g_offset = 0;
  926.  
  927.   /* Erase the oldest line... (or ellipse) */
  928.  
  929.   if (g_Count > (dl->maxlines - 1))
  930.     {
  931.       newoffs = (g_offset == dl->maxlines) ? 0 : g_offset + dl->trails;
  932.       SetAPen (rp, 0L);
  933.       switch (dl->flags)
  934.     {
  935.     case F_LINES:
  936.       Move (rp, point_start[newoffs].x, point_start[newoffs].y);
  937.       Draw (rp, point_end[newoffs].x, point_end[newoffs].y);
  938.       break;
  939.  
  940.     case F_ELLIPSES:
  941.       do_ellipse (newoffs);
  942.       break;
  943.  
  944.     case F_BOXES:
  945.       do_box (newoffs);
  946.       break;
  947.  
  948.     case F_SPLINES:
  949.       do_spline (newoffs);
  950.       break;
  951.  
  952.     case F_TEXTSTR:
  953.       do_text (newoffs);
  954.       break;
  955.  
  956.     }
  957.       SetAPen (rp, 1L);
  958.     }
  959.  
  960.   /* Calculate the next point */
  961.  
  962.   newoffs = (g_offset > 0) ? g_offset - 1 : dl->maxlines;
  963.   point_start[g_offset].x = (g_scale1 * direction.start.x) + point_start[newoffs].x;
  964.   point_start[g_offset].y = (g_scale1 * direction.start.y) + point_start[newoffs].y;
  965.  
  966.   if (dl->flags != F_TEXTSTR)
  967.     {
  968.       point_end[g_offset].x = (g_scale2 * direction.end.x) + point_end[newoffs].x;
  969.       point_end[g_offset].y = (g_scale2 * direction.end.y) + point_end[newoffs].y;
  970.     }
  971.   else
  972.     {
  973.       point_end[g_offset].x = point_start[g_offset].x + TextLength (rp, g_TStr, g_TLen);
  974.       point_end[g_offset].y = point_start[g_offset].y;
  975.     }
  976. }
  977.  
  978.  
  979. /*
  980.  *********************************************************************
  981.  */
  982.  
  983. void
  984. InitScrStructures ()
  985. {
  986.   SCREEN scr;
  987.   if (GetScreenData (&scr, sizeof (scr), WBENCHSCREEN, NULL))
  988.     {
  989.       if (scr.ViewPort.Modes & HIRES)
  990.     MAXX = scr.Width;
  991.       else
  992.     MAXX = scr.Width * 2;
  993.  
  994.       if (scr.ViewPort.Modes & LACE)
  995.     MAXY = scr.Height;
  996.       else
  997.     MAXY = scr.Height * 2;
  998.     }
  999.   else
  1000.     {
  1001.       MAXX = 640;
  1002.       MAXY = 200;
  1003.     }
  1004.   Ns.Width = MAXX;
  1005.   Nw.Width = MAXX;
  1006.   Ns.Height = MAXY;
  1007.   Nw.Height = MAXY;
  1008. }
  1009.  
  1010. /*
  1011.  *********************************************************************
  1012.  */
  1013.  
  1014. void
  1015. screenoff ()
  1016. {
  1017.   if (Scr)
  1018.     ScreenToFront (Scr);
  1019.   else if (Scr = OpenScreen (&Ns))
  1020.     {
  1021.       Nw.Screen = Scr;
  1022.       if (Win = OpenWindow (&Nw))
  1023.     {
  1024.       vp = &Scr->ViewPort;
  1025.       rp = Win->RPort;
  1026.       LoadRGB4 (vp, colour_tbl, 2L);
  1027.     }
  1028.       ShowTitle (Scr, FALSE);
  1029.     }
  1030. }
  1031.  
  1032. /*
  1033.  *********************************************************************
  1034.  */
  1035. void
  1036. screenon ()
  1037. {
  1038.   if (Win)
  1039.     CloseWindow (Win);
  1040.  
  1041.   if (Scr)
  1042.     CloseScreen (Scr);
  1043.  
  1044.   Win = NULL;
  1045.   Scr = NULL;
  1046.   vp = NULL;
  1047.   rp = NULL;
  1048. }
  1049.  
  1050. /*
  1051.  *********************************************************************
  1052.  */
  1053.  
  1054. void
  1055. do_text (int g_offset)
  1056. {
  1057.   SHORT x, y;
  1058.  
  1059.   x = (Scr->Width - TextLength (rp, g_TStr, g_TLen) - 20);
  1060.  
  1061.   y = (Scr->Height - Scr->RastPort.TxHeight - Scr->RastPort.TxBaseline - 8);
  1062.  
  1063.   if (x < 0 || y < 0)
  1064.     return;
  1065.  
  1066.   x = (x < point_start[g_offset].x) ? x : point_start[g_offset].x;
  1067.   y = (y < point_start[g_offset].y) ? y : point_start[g_offset].y;
  1068.  
  1069.   Move (rp, x, y);
  1070.   Text (rp, g_TStr, g_TLen);
  1071. }
  1072.  
  1073. /*
  1074.  *********************************************************************
  1075.  */
  1076.  
  1077. void
  1078. do_ellipse (int offs)
  1079. {
  1080.   int tempx, tempy;
  1081.  
  1082.   tempx = (point_end[offs].x > point_start[offs].x) ?
  1083.     point_end[offs].x - point_start[offs].x :
  1084.     point_start[offs].x - point_end[offs].x;
  1085.  
  1086.   tempy = (point_end[offs].y > point_start[offs].y) ?
  1087.     point_end[offs].y - point_start[offs].y :
  1088.     point_start[offs].y - point_end[offs].y;
  1089.  
  1090.   tempx = (tempx > point_start[offs].x) ? point_start[offs].x :
  1091.     ((tempx + point_start[offs].x) > BOUNDX) ? BOUNDX - point_start[offs].x :
  1092.     tempx;
  1093.  
  1094.   tempy = (tempy > point_start[offs].y) ? point_start[offs].y :
  1095.     ((tempy + point_start[offs].y) > BOUNDY) ? BOUNDY - point_start[offs].y :
  1096.     tempy;
  1097.  
  1098.   tempx = (tempx > MAXELLIPSE) ? MAXELLIPSE : tempx;
  1099.   tempy = (tempy > MAXELLIPSE) ? MAXELLIPSE : tempy;
  1100.  
  1101.   if ((tempx > 0) && (tempy > 0))
  1102.     DrawEllipse (rp, point_start[offs].x, point_start[offs].y, tempx, tempy);
  1103. }
  1104.  
  1105. /*
  1106.  *********************************************************************
  1107.  */
  1108.  
  1109. void
  1110. do_box (int K)
  1111.  
  1112. {
  1113.   int tempx, tempy;
  1114.  
  1115.   Move (rp, point_start[K].x, point_start[K].y);
  1116.   Draw (rp, point_end[K].x, point_end[K].y);
  1117.  
  1118.   tempx = MAXX - point_start[K].x;
  1119.   tempy = MAXY - point_start[K].y;
  1120.  
  1121.   if ((tempx >= 0) && (tempy >= 0))
  1122.     Draw (rp, tempx, tempy);
  1123.  
  1124.   tempx = MAXX - point_end[K].x;
  1125.   tempy = MAXY - point_end[K].y;
  1126.  
  1127.   if ((tempx >= 0) || (tempy >= 0))
  1128.     Draw (rp, tempx, tempy);
  1129.  
  1130.   Draw (rp, point_start[K].x, point_start[K].y);
  1131.  
  1132. }
  1133.  
  1134. /*
  1135.  *********************************************************************
  1136.  */
  1137.  
  1138. LONG
  1139. checkbounce_start (int index)
  1140. {
  1141.   return (point_start[index].x >= BOUNDX) | (point_start[index].y >= BOUNDY) |
  1142.     (point_start[index].x <= MINBOUND) | (point_start[index].y <= MINBOUND);
  1143.  
  1144. }
  1145.  
  1146. /*
  1147.  *********************************************************************
  1148.  */
  1149.  
  1150. LONG
  1151. checkbounce2 (int index)
  1152. {
  1153.   return (point_end[index].x >= BOUNDX) | (point_end[index].y >= BOUNDY) |
  1154.     (point_end[index].x <= MINBOUND) | (point_end[index].y <= MINBOUND);
  1155. }
  1156.  
  1157. /*
  1158.  *********************************************************************
  1159.  */
  1160.  
  1161. int
  1162. get_rand_point ()
  1163. {
  1164.   SHORT temp;
  1165.  
  1166.   temp = my_ran ();
  1167.  
  1168.   if (temp < 0)
  1169.     temp = temp * -1;
  1170.  
  1171.   temp = temp / 319 + 19;
  1172.  
  1173.   return (temp > MAXY) ? MAXY : temp;
  1174. }
  1175.  
  1176. /*
  1177.  *********************************************************************
  1178.  */
  1179.  
  1180. int
  1181. get_rand_dir ()
  1182. {
  1183.   SHORT num;
  1184.  
  1185.   num = my_ran ();
  1186.  
  1187.   return (num < -5000) ? -1 : (num > 5000) ? 1 : 0;
  1188. }
  1189.  
  1190. /*
  1191.  *********************************************************************
  1192.  */
  1193.  
  1194. int
  1195. get_rand_scale ()
  1196. {
  1197.   SHORT temp;
  1198.  
  1199.   temp = my_ran ();
  1200.  
  1201.   if (temp < 0)
  1202.     temp = temp * -1;
  1203.  
  1204.   temp = temp / 6560 + (SHORT) dl->input;
  1205.  
  1206.   return (temp > 17) ? 17 : temp;
  1207. }
  1208.  
  1209. /*
  1210.  *********************************************************************
  1211.  */
  1212.  
  1213. void
  1214. do_spline (int index)
  1215.  
  1216. {
  1217.   int index1;
  1218.   LONG_POINT p1, p2, p3, p4;
  1219.  
  1220.  
  1221.   if (index == 0)
  1222.     index1 = dl->maxlines;
  1223.   else
  1224.     index1 = index - 1;
  1225.  
  1226.   Move (rp, (LONG) (point_start[index].x), (LONG) (point_start[index].y));
  1227.  
  1228.   p1.x = point_start[index].x;
  1229.   p1.y = point_start[index].y;
  1230.  
  1231.   p2.x = point_end[index].x;
  1232.   p2.y = point_end[index].y;
  1233.  
  1234.   p3.x = point_start[index1].x;
  1235.   p3.y = point_start[index1].y;
  1236.  
  1237.   p4.x = point_end[index1].x;
  1238.   p4.y = point_end[index1].y;
  1239.  
  1240.   DrawBezierArc (Win, &p1, &p2, &p3, &p4);
  1241.  
  1242. }
  1243. /*
  1244.  *********************************************************************
  1245.  */
  1246.  
  1247. int
  1248. openlibs ()
  1249. {
  1250.  
  1251.   if ((IntuitionBase =
  1252.        (INTUITIONBASE *) OpenLibrary ("intuition.library", 37)) == NULL)
  1253.     {
  1254.       fatal_err ("\nCan't open intuition.library\n");
  1255.     }
  1256.  
  1257.   if ((GfxBase = (GFXBASE *) OpenLibrary ("graphics.library", 37)) == NULL)
  1258.     {
  1259.       fatal_err ("\nCan't open graphics.library\n");
  1260.     }
  1261.  
  1262.   return 1;
  1263. }
  1264.  
  1265.  
  1266. /*
  1267.  *********************************************************************
  1268.  */
  1269.  
  1270. void
  1271. closelibs ()
  1272. {
  1273.  
  1274.   if (IntuitionBase)
  1275.     CloseLibrary ((LIBRARY *) IntuitionBase);
  1276.  
  1277.   if (GfxBase)
  1278.     CloseLibrary ((LIBRARY *) GfxBase);
  1279.  
  1280. }
  1281. /*
  1282.  *********************************************************************
  1283.  */
  1284.  
  1285. USHORT
  1286. my_ran ()
  1287. {
  1288. /*
  1289.  * was myrand()
  1290.  */
  1291.  
  1292.   static long rv = 34987;
  1293.  
  1294.   rv = (rv * 13 + 1) ^ (rv >> 13);
  1295.   return ((USHORT) rv);
  1296. }
  1297. /*
  1298.  *********************************************************************
  1299.  */
  1300.  
  1301. void
  1302. hexit ()
  1303. {
  1304.   if (ipport)
  1305.     DeletePort (ipport);
  1306.  
  1307.   if (t_req)
  1308.     DeleteExtIO ((IOREQUEST *) t_req);
  1309.  
  1310.   if (timerport)
  1311.     DeletePort (timerport);
  1312.  
  1313.   closelibs ();
  1314.   exit (0);
  1315. }
  1316. /*
  1317.  *********************************************************************
  1318.  */
  1319.  
  1320. char *
  1321. get_flags (LONG flags)
  1322. {
  1323.   static char buf[50];
  1324.  
  1325.   buf[0] = '\0';
  1326.  
  1327.  
  1328.   if (flags & F_TEXTSTR)
  1329.     {
  1330.       strcat (buf, "TEXTSTR ");
  1331.     }
  1332.   if (flags & F_SPLINES)
  1333.     {
  1334.       strcat (buf, "SPLINES ");
  1335.     }
  1336.   if (flags & F_LINES)
  1337.     {
  1338.       strcat (buf, "LINES ");
  1339.     }
  1340.   if (flags & F_BOXES)
  1341.     {
  1342.       strcat (buf, "BOXES ");
  1343.     }
  1344.   if (flags & F_ELLIPSES)
  1345.     {
  1346.       strcat (buf, "ELLIPSES ");
  1347.     }
  1348.  
  1349.   return buf;
  1350. }
  1351. /*
  1352.  *********************************************************************
  1353.  */
  1354.  
  1355. void
  1356. pause (LONG val)
  1357. {
  1358.   t_req->tr_node.io_Command = TR_ADDREQUEST;
  1359.   t_req->tr_time.tv_secs = 0;
  1360.   t_req->tr_time.tv_micro = val;
  1361.  
  1362.   DoIO ((IOREQUEST *) t_req);
  1363. }
  1364. /*
  1365.  *********************************************************************
  1366.  */
  1367.  
  1368. void
  1369. open_timer ()
  1370. {
  1371.  
  1372.   if ((timerport = CreatePort (DLINEART_TIMER, 0)) == NULL)
  1373.     {
  1374.       fatal_err ("Timer Port create failure\n");
  1375.     }
  1376.  
  1377.   if ((t_req = (TIMEREQUEST *) CreateExtIO ((MSGPORT *) timerport,
  1378.                         sizeof (TIMEREQUEST))) == NULL)
  1379.     {
  1380.       fatal_err ("Couldn't CreateExtIO in open_timer()\n");
  1381.     }
  1382.  
  1383.   if (OpenDevice (TIMERNAME, UNIT_MICROHZ, (IOREQUEST *) t_req, 0L) != 0)
  1384.     {
  1385.       fatal_err ("Couldn't open MicroHz Timer\n");
  1386.     }
  1387.  
  1388.   TimerBase = (LIBRARY *) t_req->tr_node.io_Device;
  1389. }
  1390.  
  1391. /*
  1392.  *********************************************************************
  1393.  */
  1394.  
  1395. /*
  1396.  * returns number of msecs between first ECLOCK and second ECLOCK 
  1397.  *
  1398.  * (GMD)
  1399.  *
  1400.  * - not precise, but a hack ; divides (shifts) by 1024 not 1000. 
  1401.  *
  1402.  */
  1403.  
  1404. LONG
  1405. time_diff (ULONG e_freq, ECLOCKVAL * e_val1, ECLOCKVAL * e_val2)
  1406.  
  1407. {
  1408.   LONG temp, msecs;
  1409.  
  1410.   if (e_val2->ev_lo > e_val1->ev_lo)
  1411.     {
  1412.       temp = e_val2->ev_lo - e_val1->ev_lo;
  1413.     }
  1414.   else
  1415.     {
  1416.       temp = e_val1->ev_lo - e_val2->ev_lo;
  1417.     }
  1418.  
  1419.   /*
  1420.    * convert to msecs
  1421.    */
  1422.  
  1423.   e_freq = e_freq >> 10;    /* roughly ,  /1024 */
  1424.  
  1425.   msecs = temp / e_freq;
  1426.  
  1427.   return msecs;
  1428. }
  1429. /*
  1430.  *********************************************************************
  1431.  */
  1432.  
  1433. static int c3;
  1434.  
  1435. void
  1436. ChangeColour (MY_COL flag)
  1437. {
  1438.   UWORD temp = RangeRand (4096);    /*GMD */
  1439.  
  1440.   static int comb[] =
  1441.   {
  1442.     0x00F,
  1443.     0xF0F,
  1444.     0x0FF,
  1445.     0x8F0,
  1446.     0xF00,
  1447.     0x0F8,
  1448.     0xF80,
  1449.     0x88F,
  1450.     0xF88,
  1451.     0x08F,
  1452.     0xF08,
  1453.     0x0F0,
  1454.     0x8F8,
  1455.     0xF0F,
  1456.     0x0F3,
  1457.     0x80F,
  1458.   };
  1459.  
  1460.  
  1461.   if (flag == COL_RGB)
  1462.     {
  1463.       ++c3;
  1464.       temp = comb[c3 % 16];
  1465.     }
  1466.  
  1467.  
  1468.   colour_tbl[1] = temp & 0xFFF;
  1469.   LoadRGB4 (vp, colour_tbl, 2L);
  1470. }
  1471.  
  1472. /*
  1473.  *********************************************************************
  1474.  */
  1475.  
  1476. void
  1477. mouse_off ()
  1478. {
  1479.  
  1480.   WaitTOF ();
  1481.   OFF_SPRITE;
  1482.   custom.spr[0].dataa = 0;    /*  sprite0 DMA  */
  1483.   custom.spr[0].datab = 0;    /*  data register */
  1484. #if 0
  1485.   SetPointer (Win, Mouse, 16, 16, 0, 0);
  1486. #endif
  1487.  
  1488. }
  1489. /*
  1490.  *********************************************************************
  1491.  */
  1492.  
  1493. void
  1494. mouse_on ()
  1495. {
  1496.  
  1497.   ON_SPRITE;
  1498.  
  1499. }
  1500.  
  1501. /*
  1502.  *********************************************************************
  1503.  */
  1504.  
  1505. /*
  1506.  * The following code taken from Fish Disk 97 , with a small modification
  1507.  * (reals -> longs, for speed)  ; GMD
  1508.  */
  1509.  
  1510. /*<<<<<<<<<<<<<<<<<<<<<<<< code extract follows >>>>>>>>>>>>>>>>>>>>> */
  1511.  
  1512. /* The routines in this file are copyright (c) 1987 by Helene (Lee) Taran.
  1513.  * Permission is granted for use and free distribution as long as the
  1514.  * original author's name is included with the code.
  1515.  */
  1516.  
  1517.  
  1518. /*
  1519.  *  Midpoint: returns the midpoint of the line through <p0> and <p1> 
  1520.  */
  1521.  
  1522. void
  1523. Midpoint (m, p0, p1)
  1524.      LONG_POINT *m, *p0, *p1;
  1525. {
  1526.   m->x = (p0->x + p1->x) / 2;
  1527.   m->y = (p0->y + p1->y) / 2;
  1528. }
  1529.  
  1530.  
  1531. /* DrawBezierArc: draws a bezier arc between the 4 given points by
  1532.  * recursively subdividing the curve until each segment is close
  1533.  * enough to be rendered as a line.
  1534.  * Assumes that your window <w> has been initialized and opened and that
  1535.  * in addition to the intuition library, the graphics library is open
  1536.  */
  1537.  
  1538. #define CLOSENESS 8
  1539.  
  1540. void
  1541. DrawBezierArc (w, p000, p001, p011, p111)
  1542.      struct Window *w;        /* draw the arc in this window */
  1543.      LONG_POINT *p000, *p001, *p011, *p111;    /* bezier control points */
  1544. {
  1545.   LONG_POINT p00t, p0t1, pt11, p0tt, ptt1, pttt;
  1546.  
  1547.   LONG delta1 = (p001->x * p011->y - p001->y * p011->x) -
  1548.   (p000->x * p011->y - p000->y * p011->x) +
  1549.   (p000->x * p001->y - p000->y * p001->x);
  1550.  
  1551.   LONG delta2 = (p111->x * p011->y - p111->y * p011->x) -
  1552.   (p000->x * p011->y - p000->y * p011->x) +
  1553.   (p000->x * p111->y - p000->y * p111->x);
  1554.  
  1555.   if ((delta1 + delta2) <= CLOSENESS)
  1556.     {                /* so close, just draw a line */
  1557.       Move (w->RPort, (long) p000->x, (long) p000->y);
  1558.       Draw (w->RPort, (long) p111->x, (long) p111->y);
  1559.     }
  1560.   else
  1561.     {                /* divide the arc into two smaller bezier arcs */
  1562.       Midpoint (&p00t, p000, p001);
  1563.       Midpoint (&p0t1, p001, p011);
  1564.       Midpoint (&pt11, p011, p111);
  1565.       Midpoint (&p0tt, &p00t, &p0t1);
  1566.       Midpoint (&ptt1, &p0t1, &pt11);
  1567.       Midpoint (&pttt, &p0tt, &ptt1);
  1568.       DrawBezierArc (w, p000, &p00t, &p0tt, &pttt);
  1569.       DrawBezierArc (w, &pttt, &ptt1, &pt11, p111);
  1570.     }
  1571. }
  1572. /*<<<<<<<<<<<<<<<<<<<<<< end ; code extract follows >>>>>>>>>>>>>>>>>>>>> */
  1573.  
  1574. /*--*/
  1575.  
  1576.  
  1577. /*
  1578.  *********************************************************************
  1579.  */
  1580.  
  1581. void
  1582. usage (void)
  1583. {
  1584.   int j = 0;
  1585.   char *ptr;
  1586.   static char *ray[] =
  1587. /* *INDENT-OFF* */
  1588.  
  1589.   {
  1590. "dlineart options", 
  1591. "",
  1592. "    -q         Stop dlineart if activated",
  1593. "    -v         Print parameters/defaults of a running dlineart",
  1594. "    -b         Draw boxes                  [default = yes]",
  1595. "    -e         Draw ellipses               [default = yes]",
  1596. "    -s         Draw splines                [default = yes]",
  1597. "    -SX        Change colour every X secs  [default = 1]",
  1598. "    -pX        Change pattern every X secs [default = 5]",
  1599. "    -lX        Draw X lines before erasing the last one.",
  1600. "    -zX        Slow display; X=0 is fastest, X=9 slowest",
  1601. "    -t         This leaves a trail (one out of every 'l' lines)",
  1602. "    -T\"string\" write <string> (default BOING)",
  1603. "    -h         Help, this message",
  1604. "    -iX        X is an integer between 1 and 9 that will change",
  1605. "                the minimum distance between successive endpoints for",
  1606. "                each line drawn. High numbers are faster.",
  1607. "",
  1608. " To invoke dlineart, type \"Run dlineart >nil: <nil: options...\"",
  1609. NULL
  1610.  
  1611.   };
  1612.  
  1613. /* *INDENT-ON* */
  1614.  
  1615.  
  1616.  
  1617.  
  1618.  
  1619.  
  1620.  
  1621.  
  1622.  
  1623.  
  1624.  
  1625.  
  1626.   /*
  1627.    * Version
  1628.    */
  1629.   printf ("%s\n\n", Version);
  1630.  
  1631.   while (ptr = ray[j++])
  1632.     printf ("%s\n", ptr);
  1633. }
  1634.  
  1635.  
  1636. /*
  1637.  *********************************************************************
  1638.  */
  1639.  
  1640. void
  1641. fatal_err (char *ptr)
  1642. {
  1643.  
  1644.   static LONG DBFh;
  1645.  
  1646.   char f_buf[256];
  1647.  
  1648.   DBFh = Open ("CON:0/0/500/100/DLineArt-FATAL", 1006);
  1649.  
  1650.   if (DBFh == 0)
  1651.     hexit ();
  1652.  
  1653.   Write (DBFh, ptr, strlen (ptr));
  1654.  
  1655.   sprintf (f_buf, "\nHit RET to exit\n");
  1656.  
  1657.   Write (DBFh, f_buf, strlen (f_buf));
  1658.  
  1659.   if (FGetC (DBFh))
  1660.     Close (DBFh);
  1661.  
  1662.   hexit ();
  1663.  
  1664. }
  1665.  
  1666. /*
  1667.  *********************************************************************
  1668.  */
  1669.  
  1670. void
  1671. v_option ()
  1672. {
  1673.   printf ("%s\n\n", Version);
  1674.   dl = g_dlb;
  1675.  
  1676.   printf ("(-b, -e, -s)  = %s\n", get_flags (dl->flags_orig));
  1677.   if (dl->flags_orig & F_TEXTSTR)
  1678.     {
  1679.       if (strlen (dl->text))
  1680.     printf ("(-T) text str = %s\n", dl->text);
  1681.     }
  1682.  
  1683.   printf ("(-i) input    = %d\n", dl->input);
  1684.   printf ("(-z) speed    = %d [range : 0 - 9]\n",
  1685.       dl->z_delay / Z_FACTOR);
  1686.   printf ("(-S) colour   = change every %d secs\n",
  1687.       dl->col_chg_spd / 1000);
  1688.   printf ("(-p) pattern  = change every %d secs\n",
  1689.       dl->pat_chg_time / 1000);
  1690.   printf ("(-l) maxlines = %d\n", dl->maxlines);
  1691.   printf ("(-t) trails   = %d\n", dl->trails);
  1692. }
  1693.  
  1694. /*    */
  1695.